5 * ^---- causes phpunit to use a higher timeout threshold
11 class FileBackendTest
extends MediaWikiTestCase
{
12 private $backend, $multiBackend;
13 private $filesToPrune = array();
14 private static $backendToUse;
17 global $wgFileBackends;
19 $tmpPrefix = wfTempDir() . '/filebackend-unittest-' . time() . '-' . mt_rand();
20 if ( $this->getCliArg( 'use-filebackend=' ) ) {
21 if ( self
::$backendToUse ) {
22 $this->singleBackend
= self
::$backendToUse;
24 $name = $this->getCliArg( 'use-filebackend=' );
26 foreach ( $wgFileBackends as $conf ) {
27 if ( $conf['name'] == $name ) {
32 $useConfig['name'] = 'localtesting'; // swap name
33 $useConfig['shardViaHashLevels'] = array( // test sharding
34 'unittest-cont1' => array( 'levels' => 1, 'base' => 16, 'repeat' => 1 )
36 $class = $useConfig['class'];
37 self
::$backendToUse = new $class( $useConfig );
38 $this->singleBackend
= self
::$backendToUse;
41 $this->singleBackend
= new FSFileBackend( array(
42 'name' => 'localtesting',
43 'lockManager' => 'fsLockManager',
44 #'parallelize' => 'implicit',
45 'containerPaths' => array(
46 'unittest-cont1' => "{$tmpPrefix}-localtesting-cont1",
47 'unittest-cont2' => "{$tmpPrefix}-localtesting-cont2" )
50 $this->multiBackend
= new FileBackendMultiWrite( array(
51 'name' => 'localtesting',
52 'lockManager' => 'fsLockManager',
53 'parallelize' => 'implicit',
56 'name' => 'localmutlitesting1',
57 'class' => 'FSFileBackend',
58 'lockManager' => 'nullLockManager',
59 'containerPaths' => array(
60 'unittest-cont1' => "{$tmpPrefix}-localtestingmulti1-cont1",
61 'unittest-cont2' => "{$tmpPrefix}-localtestingmulti1-cont2" ),
62 'isMultiMaster' => false
65 'name' => 'localmutlitesting2',
66 'class' => 'FSFileBackend',
67 'lockManager' => 'nullLockManager',
68 'containerPaths' => array(
69 'unittest-cont1' => "{$tmpPrefix}-localtestingmulti2-cont1",
70 'unittest-cont2' => "{$tmpPrefix}-localtestingmulti2-cont2" ),
71 'isMultiMaster' => true
75 $this->filesToPrune
= array();
78 private function baseStorePath() {
79 return 'mwstore://localtesting';
82 private function backendClass() {
83 return get_class( $this->backend
);
87 * @dataProvider provider_testIsStoragePath
89 public function testIsStoragePath( $path, $isStorePath ) {
90 $this->assertEquals( $isStorePath, FileBackend
::isStoragePath( $path ),
91 "FileBackend::isStoragePath on path '$path'" );
94 function provider_testIsStoragePath() {
96 array( 'mwstore://', true ),
97 array( 'mwstore://backend', true ),
98 array( 'mwstore://backend/container', true ),
99 array( 'mwstore://backend/container/', true ),
100 array( 'mwstore://backend/container/path', true ),
101 array( 'mwstore://backend//container/', true ),
102 array( 'mwstore://backend//container//', true ),
103 array( 'mwstore://backend//container//path', true ),
104 array( 'mwstore:///', true ),
105 array( 'mwstore:/', false ),
106 array( 'mwstore:', false ),
111 * @dataProvider provider_testSplitStoragePath
113 public function testSplitStoragePath( $path, $res ) {
114 $this->assertEquals( $res, FileBackend
::splitStoragePath( $path ),
115 "FileBackend::splitStoragePath on path '$path'" );
118 function provider_testSplitStoragePath() {
120 array( 'mwstore://backend/container', array( 'backend', 'container', '' ) ),
121 array( 'mwstore://backend/container/', array( 'backend', 'container', '' ) ),
122 array( 'mwstore://backend/container/path', array( 'backend', 'container', 'path' ) ),
123 array( 'mwstore://backend/container//path', array( 'backend', 'container', '/path' ) ),
124 array( 'mwstore://backend//container/path', array( null, null, null ) ),
125 array( 'mwstore://backend//container//path', array( null, null, null ) ),
126 array( 'mwstore://', array( null, null, null ) ),
127 array( 'mwstore://backend', array( null, null, null ) ),
128 array( 'mwstore:///', array( null, null, null ) ),
129 array( 'mwstore:/', array( null, null, null ) ),
130 array( 'mwstore:', array( null, null, null ) )
135 * @dataProvider provider_normalizeStoragePath
137 public function testNormalizeStoragePath( $path, $res ) {
138 $this->assertEquals( $res, FileBackend
::normalizeStoragePath( $path ),
139 "FileBackend::normalizeStoragePath on path '$path'" );
142 function provider_normalizeStoragePath() {
144 array( 'mwstore://backend/container', 'mwstore://backend/container' ),
145 array( 'mwstore://backend/container/', 'mwstore://backend/container' ),
146 array( 'mwstore://backend/container/path', 'mwstore://backend/container/path' ),
147 array( 'mwstore://backend/container//path', 'mwstore://backend/container/path' ),
148 array( 'mwstore://backend/container///path', 'mwstore://backend/container/path' ),
149 array( 'mwstore://backend/container///path//to///obj', 'mwstore://backend/container/path/to/obj',
150 array( 'mwstore://', null ),
151 array( 'mwstore://backend', null ),
152 array( 'mwstore://backend//container/path', null ),
153 array( 'mwstore://backend//container//path', null ),
154 array( 'mwstore:///', null ),
155 array( 'mwstore:/', null ),
156 array( 'mwstore:', null ), )
161 * @dataProvider provider_testParentStoragePath
163 public function testParentStoragePath( $path, $res ) {
164 $this->assertEquals( $res, FileBackend
::parentStoragePath( $path ),
165 "FileBackend::parentStoragePath on path '$path'" );
168 function provider_testParentStoragePath() {
170 array( 'mwstore://backend/container/path/to/obj', 'mwstore://backend/container/path/to' ),
171 array( 'mwstore://backend/container/path/to', 'mwstore://backend/container/path' ),
172 array( 'mwstore://backend/container/path', 'mwstore://backend/container' ),
173 array( 'mwstore://backend/container', null ),
174 array( 'mwstore://backend/container/path/to/obj/', 'mwstore://backend/container/path/to' ),
175 array( 'mwstore://backend/container/path/to/', 'mwstore://backend/container/path' ),
176 array( 'mwstore://backend/container/path/', 'mwstore://backend/container' ),
177 array( 'mwstore://backend/container/', null ),
182 * @dataProvider provider_testExtensionFromPath
184 public function testExtensionFromPath( $path, $res ) {
185 $this->assertEquals( $res, FileBackend
::extensionFromPath( $path ),
186 "FileBackend::extensionFromPath on path '$path'" );
189 function provider_testExtensionFromPath() {
191 array( 'mwstore://backend/container/path.txt', 'txt' ),
192 array( 'mwstore://backend/container/path.svg.png', 'png' ),
193 array( 'mwstore://backend/container/path', '' ),
194 array( 'mwstore://backend/container/path.', '' ),
199 * @dataProvider provider_testStore
201 public function testStore( $op ) {
202 $this->filesToPrune
[] = $op['src'];
204 $this->backend
= $this->singleBackend
;
205 $this->tearDownFiles();
206 $this->doTestStore( $op );
207 $this->tearDownFiles();
209 $this->backend
= $this->multiBackend
;
210 $this->tearDownFiles();
211 $this->doTestStore( $op );
212 $this->filesToPrune
[] = $op['src']; # avoid file leaking
213 $this->tearDownFiles();
216 private function doTestStore( $op ) {
217 $backendName = $this->backendClass();
219 $source = $op['src'];
221 $this->prepare( array( 'dir' => dirname( $dest ) ) );
223 file_put_contents( $source, "Unit test file" );
225 if ( isset( $op['overwrite'] ) ||
isset( $op['overwriteSame'] ) ) {
226 $this->backend
->store( $op );
229 $status = $this->backend
->doOperation( $op );
231 $this->assertGoodStatus( $status,
232 "Store from $source to $dest succeeded without warnings ($backendName)." );
233 $this->assertEquals( true, $status->isOK(),
234 "Store from $source to $dest succeeded ($backendName)." );
235 $this->assertEquals( array( 0 => true ), $status->success
,
236 "Store from $source to $dest has proper 'success' field in Status ($backendName)." );
237 $this->assertEquals( true, file_exists( $source ),
238 "Source file $source still exists ($backendName)." );
239 $this->assertEquals( true, $this->backend
->fileExists( array( 'src' => $dest ) ),
240 "Destination file $dest exists ($backendName)." );
242 $this->assertEquals( filesize( $source ),
243 $this->backend
->getFileSize( array( 'src' => $dest ) ),
244 "Destination file $dest has correct size ($backendName)." );
246 $props1 = FSFile
::getPropsFromPath( $source );
247 $props2 = $this->backend
->getFileProps( array( 'src' => $dest ) );
248 $this->assertEquals( $props1, $props2,
249 "Source and destination have the same props ($backendName)." );
251 $this->assertBackendPathsConsistent( array( $dest ) );
254 public function provider_testStore() {
257 $tmpName = TempFSFile
::factory( "unittests_", 'txt' )->getPath();
258 $toPath = $this->baseStorePath() . '/unittest-cont1/e/fun/obj1.txt';
259 $op = array( 'op' => 'store', 'src' => $tmpName, 'dst' => $toPath );
267 $op2['overwrite'] = true;
275 $op2['overwriteSame'] = true;
286 * @dataProvider provider_testCopy
288 public function testCopy( $op ) {
289 $this->backend
= $this->singleBackend
;
290 $this->tearDownFiles();
291 $this->doTestCopy( $op );
292 $this->tearDownFiles();
294 $this->backend
= $this->multiBackend
;
295 $this->tearDownFiles();
296 $this->doTestCopy( $op );
297 $this->tearDownFiles();
300 private function doTestCopy( $op ) {
301 $backendName = $this->backendClass();
303 $source = $op['src'];
305 $this->prepare( array( 'dir' => dirname( $source ) ) );
306 $this->prepare( array( 'dir' => dirname( $dest ) ) );
308 $status = $this->backend
->doOperation(
309 array( 'op' => 'create', 'content' => 'blahblah', 'dst' => $source ) );
310 $this->assertGoodStatus( $status,
311 "Creation of file at $source succeeded ($backendName)." );
313 if ( isset( $op['overwrite'] ) ||
isset( $op['overwriteSame'] ) ) {
314 $this->backend
->copy( $op );
317 $status = $this->backend
->doOperation( $op );
319 $this->assertGoodStatus( $status,
320 "Copy from $source to $dest succeeded without warnings ($backendName)." );
321 $this->assertEquals( true, $status->isOK(),
322 "Copy from $source to $dest succeeded ($backendName)." );
323 $this->assertEquals( array( 0 => true ), $status->success
,
324 "Copy from $source to $dest has proper 'success' field in Status ($backendName)." );
325 $this->assertEquals( true, $this->backend
->fileExists( array( 'src' => $source ) ),
326 "Source file $source still exists ($backendName)." );
327 $this->assertEquals( true, $this->backend
->fileExists( array( 'src' => $dest ) ),
328 "Destination file $dest exists after copy ($backendName)." );
331 $this->backend
->getFileSize( array( 'src' => $source ) ),
332 $this->backend
->getFileSize( array( 'src' => $dest ) ),
333 "Destination file $dest has correct size ($backendName)." );
335 $props1 = $this->backend
->getFileProps( array( 'src' => $source ) );
336 $props2 = $this->backend
->getFileProps( array( 'src' => $dest ) );
337 $this->assertEquals( $props1, $props2,
338 "Source and destination have the same props ($backendName)." );
340 $this->assertBackendPathsConsistent( array( $source, $dest ) );
343 public function provider_testCopy() {
346 $source = $this->baseStorePath() . '/unittest-cont1/e/file.txt';
347 $dest = $this->baseStorePath() . '/unittest-cont2/a/fileMoved.txt';
349 $op = array( 'op' => 'copy', 'src' => $source, 'dst' => $dest );
357 $op2['overwrite'] = true;
365 $op2['overwriteSame'] = true;
376 * @dataProvider provider_testMove
378 public function testMove( $op ) {
379 $this->backend
= $this->singleBackend
;
380 $this->tearDownFiles();
381 $this->doTestMove( $op );
382 $this->tearDownFiles();
384 $this->backend
= $this->multiBackend
;
385 $this->tearDownFiles();
386 $this->doTestMove( $op );
387 $this->tearDownFiles();
390 private function doTestMove( $op ) {
391 $backendName = $this->backendClass();
393 $source = $op['src'];
395 $this->prepare( array( 'dir' => dirname( $source ) ) );
396 $this->prepare( array( 'dir' => dirname( $dest ) ) );
398 $status = $this->backend
->doOperation(
399 array( 'op' => 'create', 'content' => 'blahblah', 'dst' => $source ) );
400 $this->assertGoodStatus( $status,
401 "Creation of file at $source succeeded ($backendName)." );
403 if ( isset( $op['overwrite'] ) ||
isset( $op['overwriteSame'] ) ) {
404 $this->backend
->copy( $op );
407 $status = $this->backend
->doOperation( $op );
408 $this->assertGoodStatus( $status,
409 "Move from $source to $dest succeeded without warnings ($backendName)." );
410 $this->assertEquals( true, $status->isOK(),
411 "Move from $source to $dest succeeded ($backendName)." );
412 $this->assertEquals( array( 0 => true ), $status->success
,
413 "Move from $source to $dest has proper 'success' field in Status ($backendName)." );
414 $this->assertEquals( false, $this->backend
->fileExists( array( 'src' => $source ) ),
415 "Source file $source does not still exists ($backendName)." );
416 $this->assertEquals( true, $this->backend
->fileExists( array( 'src' => $dest ) ),
417 "Destination file $dest exists after move ($backendName)." );
419 $this->assertNotEquals(
420 $this->backend
->getFileSize( array( 'src' => $source ) ),
421 $this->backend
->getFileSize( array( 'src' => $dest ) ),
422 "Destination file $dest has correct size ($backendName)." );
424 $props1 = $this->backend
->getFileProps( array( 'src' => $source ) );
425 $props2 = $this->backend
->getFileProps( array( 'src' => $dest ) );
426 $this->assertEquals( false, $props1['fileExists'],
427 "Source file does not exist accourding to props ($backendName)." );
428 $this->assertEquals( true, $props2['fileExists'],
429 "Destination file exists accourding to props ($backendName)." );
431 $this->assertBackendPathsConsistent( array( $source, $dest ) );
434 public function provider_testMove() {
437 $source = $this->baseStorePath() . '/unittest-cont1/e/file.txt';
438 $dest = $this->baseStorePath() . '/unittest-cont2/a/fileMoved.txt';
440 $op = array( 'op' => 'move', 'src' => $source, 'dst' => $dest );
448 $op2['overwrite'] = true;
456 $op2['overwriteSame'] = true;
467 * @dataProvider provider_testDelete
469 public function testDelete( $op, $withSource, $okStatus ) {
470 $this->backend
= $this->singleBackend
;
471 $this->tearDownFiles();
472 $this->doTestDelete( $op, $withSource, $okStatus );
473 $this->tearDownFiles();
475 $this->backend
= $this->multiBackend
;
476 $this->tearDownFiles();
477 $this->doTestDelete( $op, $withSource, $okStatus );
478 $this->tearDownFiles();
481 private function doTestDelete( $op, $withSource, $okStatus ) {
482 $backendName = $this->backendClass();
484 $source = $op['src'];
485 $this->prepare( array( 'dir' => dirname( $source ) ) );
488 $status = $this->backend
->doOperation(
489 array( 'op' => 'create', 'content' => 'blahblah', 'dst' => $source ) );
490 $this->assertGoodStatus( $status,
491 "Creation of file at $source succeeded ($backendName)." );
494 $status = $this->backend
->doOperation( $op );
496 $this->assertGoodStatus( $status,
497 "Deletion of file at $source succeeded without warnings ($backendName)." );
498 $this->assertEquals( true, $status->isOK(),
499 "Deletion of file at $source succeeded ($backendName)." );
500 $this->assertEquals( array( 0 => true ), $status->success
,
501 "Deletion of file at $source has proper 'success' field in Status ($backendName)." );
503 $this->assertEquals( false, $status->isOK(),
504 "Deletion of file at $source failed ($backendName)." );
507 $this->assertEquals( false, $this->backend
->fileExists( array( 'src' => $source ) ),
508 "Source file $source does not exist after move ($backendName)." );
511 $this->backend
->getFileSize( array( 'src' => $source ) ),
512 "Source file $source has correct size (false) ($backendName)." );
514 $props1 = $this->backend
->getFileProps( array( 'src' => $source ) );
515 $this->assertFalse( $props1['fileExists'],
516 "Source file $source does not exist according to props ($backendName)." );
518 $this->assertBackendPathsConsistent( array( $source ) );
521 public function provider_testDelete() {
524 $source = $this->baseStorePath() . '/unittest-cont1/e/myfacefile.txt';
526 $op = array( 'op' => 'delete', 'src' => $source );
535 false, // without source
539 $op['ignoreMissingSource'] = true;
542 false, // without source
550 * @dataProvider provider_testCreate
552 public function testCreate( $op, $alreadyExists, $okStatus, $newSize ) {
553 $this->backend
= $this->singleBackend
;
554 $this->tearDownFiles();
555 $this->doTestCreate( $op, $alreadyExists, $okStatus, $newSize );
556 $this->tearDownFiles();
558 $this->backend
= $this->multiBackend
;
559 $this->tearDownFiles();
560 $this->doTestCreate( $op, $alreadyExists, $okStatus, $newSize );
561 $this->tearDownFiles();
564 private function doTestCreate( $op, $alreadyExists, $okStatus, $newSize ) {
565 $backendName = $this->backendClass();
568 $this->prepare( array( 'dir' => dirname( $dest ) ) );
570 $oldText = 'blah...blah...waahwaah';
571 if ( $alreadyExists ) {
572 $status = $this->backend
->doOperation(
573 array( 'op' => 'create', 'content' => $oldText, 'dst' => $dest ) );
574 $this->assertGoodStatus( $status,
575 "Creation of file at $dest succeeded ($backendName)." );
578 $status = $this->backend
->doOperation( $op );
580 $this->assertGoodStatus( $status,
581 "Creation of file at $dest succeeded without warnings ($backendName)." );
582 $this->assertEquals( true, $status->isOK(),
583 "Creation of file at $dest succeeded ($backendName)." );
584 $this->assertEquals( array( 0 => true ), $status->success
,
585 "Creation of file at $dest has proper 'success' field in Status ($backendName)." );
587 $this->assertEquals( false, $status->isOK(),
588 "Creation of file at $dest failed ($backendName)." );
591 $this->assertEquals( true, $this->backend
->fileExists( array( 'src' => $dest ) ),
592 "Destination file $dest exists after creation ($backendName)." );
594 $props1 = $this->backend
->getFileProps( array( 'src' => $dest ) );
595 $this->assertEquals( true, $props1['fileExists'],
596 "Destination file $dest exists according to props ($backendName)." );
597 if ( $okStatus ) { // file content is what we saved
598 $this->assertEquals( $newSize, $props1['size'],
599 "Destination file $dest has expected size according to props ($backendName)." );
600 $this->assertEquals( $newSize,
601 $this->backend
->getFileSize( array( 'src' => $dest ) ),
602 "Destination file $dest has correct size ($backendName)." );
603 } else { // file content is some other previous text
604 $this->assertEquals( strlen( $oldText ), $props1['size'],
605 "Destination file $dest has original size according to props ($backendName)." );
606 $this->assertEquals( strlen( $oldText ),
607 $this->backend
->getFileSize( array( 'src' => $dest ) ),
608 "Destination file $dest has original size according to props ($backendName)." );
611 $this->assertBackendPathsConsistent( array( $dest ) );
615 * @dataProvider provider_testCreate
617 public function provider_testCreate() {
620 $dest = $this->baseStorePath() . '/unittest-cont2/a/myspacefile.txt';
622 $op = array( 'op' => 'create', 'content' => 'test test testing', 'dst' => $dest );
625 false, // no dest already exists
627 strlen( $op['content'] )
631 $op2['content'] = "\n";
634 false, // no dest already exists
636 strlen( $op2['content'] )
640 $op2['content'] = "fsf\n waf 3kt";
643 true, // dest already exists
645 strlen( $op2['content'] )
649 $op2['content'] = "egm'g gkpe gpqg eqwgwqg";
650 $op2['overwrite'] = true;
653 true, // dest already exists
655 strlen( $op2['content'] )
659 $op2['content'] = "39qjmg3-qg";
660 $op2['overwriteSame'] = true;
663 true, // dest already exists
665 strlen( $op2['content'] )
671 public function testDoQuickOperations() {
672 $this->backend
= $this->singleBackend
;
673 $this->doTestDoQuickOperations();
674 $this->tearDownFiles();
676 $this->backend
= $this->multiBackend
;
677 $this->doTestDoQuickOperations();
678 $this->tearDownFiles();
681 private function doTestDoQuickOperations() {
682 $backendName = $this->backendClass();
684 $base = $this->baseStorePath();
686 "$base/unittest-cont1/e/fileA.a",
687 "$base/unittest-cont1/e/fileB.a",
688 "$base/unittest-cont1/e/fileC.a"
692 foreach ( $files as $path ) {
693 $status = $this->prepare( array( 'dir' => dirname( $path ) ) );
694 $this->assertGoodStatus( $status,
695 "Preparing $path succeeded without warnings ($backendName)." );
696 $ops[] = array( 'op' => 'create', 'dst' => $path, 'content' => mt_rand(0,50000) );
697 $purgeOps[] = array( 'op' => 'delete', 'src' => $path );
699 $purgeOps[] = array( 'op' => 'null' );
700 $status = $this->backend
->doQuickOperations( $ops );
701 $this->assertGoodStatus( $status,
702 "Creation of source files succeeded ($backendName)." );
704 foreach ( $files as $file ) {
705 $this->assertTrue( $this->backend
->fileExists( array( 'src' => $file ) ),
706 "File $file exists." );
709 $status = $this->backend
->doQuickOperations( $purgeOps );
710 $this->assertGoodStatus( $status,
711 "Quick deletion of source files succeeded ($backendName)." );
713 foreach ( $files as $file ) {
714 $this->assertFalse( $this->backend
->fileExists( array( 'src' => $file ) ),
715 "File $file purged." );
720 * @dataProvider provider_testConcatenate
722 public function testConcatenate( $op, $srcs, $srcsContent, $alreadyExists, $okStatus ) {
723 $this->filesToPrune
[] = $op['dst'];
725 $this->backend
= $this->singleBackend
;
726 $this->tearDownFiles();
727 $this->doTestConcatenate( $op, $srcs, $srcsContent, $alreadyExists, $okStatus );
728 $this->tearDownFiles();
730 $this->backend
= $this->multiBackend
;
731 $this->tearDownFiles();
732 $this->doTestConcatenate( $op, $srcs, $srcsContent, $alreadyExists, $okStatus );
733 $this->filesToPrune
[] = $op['dst']; # avoid file leaking
734 $this->tearDownFiles();
737 private function doTestConcatenate( $params, $srcs, $srcsContent, $alreadyExists, $okStatus ) {
738 $backendName = $this->backendClass();
743 foreach ( $srcs as $i => $source ) {
744 $this->prepare( array( 'dir' => dirname( $source ) ) );
746 'op' => 'create', // operation
747 'dst' => $source, // source
748 'content' => $srcsContent[$i]
750 $expContent .= $srcsContent[$i];
752 $status = $this->backend
->doOperations( $ops );
754 $this->assertGoodStatus( $status,
755 "Creation of source files succeeded ($backendName)." );
757 $dest = $params['dst'];
758 if ( $alreadyExists ) {
759 $ok = file_put_contents( $dest, 'blah...blah...waahwaah' ) !== false;
760 $this->assertEquals( true, $ok,
761 "Creation of file at $dest succeeded ($backendName)." );
763 $ok = file_put_contents( $dest, '' ) !== false;
764 $this->assertEquals( true, $ok,
765 "Creation of 0-byte file at $dest succeeded ($backendName)." );
768 // Combine the files into one
769 $status = $this->backend
->concatenate( $params );
771 $this->assertGoodStatus( $status,
772 "Creation of concat file at $dest succeeded without warnings ($backendName)." );
773 $this->assertEquals( true, $status->isOK(),
774 "Creation of concat file at $dest succeeded ($backendName)." );
776 $this->assertEquals( false, $status->isOK(),
777 "Creation of concat file at $dest failed ($backendName)." );
781 $this->assertEquals( true, is_file( $dest ),
782 "Dest concat file $dest exists after creation ($backendName)." );
784 $this->assertEquals( true, is_file( $dest ),
785 "Dest concat file $dest exists after failed creation ($backendName)." );
788 $contents = file_get_contents( $dest );
789 $this->assertNotEquals( false, $contents, "File at $dest exists ($backendName)." );
792 $this->assertEquals( $expContent, $contents,
793 "Concat file at $dest has correct contents ($backendName)." );
795 $this->assertNotEquals( $expContent, $contents,
796 "Concat file at $dest has correct contents ($backendName)." );
800 function provider_testConcatenate() {
803 $rand = mt_rand( 0, 2000000000 ) . time();
804 $dest = wfTempDir() . "/randomfile!$rand.txt";
806 $this->baseStorePath() . '/unittest-cont1/e/file1.txt',
807 $this->baseStorePath() . '/unittest-cont1/e/file2.txt',
808 $this->baseStorePath() . '/unittest-cont1/e/file3.txt',
809 $this->baseStorePath() . '/unittest-cont1/e/file4.txt',
810 $this->baseStorePath() . '/unittest-cont1/e/file5.txt',
811 $this->baseStorePath() . '/unittest-cont1/e/file6.txt',
812 $this->baseStorePath() . '/unittest-cont1/e/file7.txt',
813 $this->baseStorePath() . '/unittest-cont1/e/file8.txt',
814 $this->baseStorePath() . '/unittest-cont1/e/file9.txt',
815 $this->baseStorePath() . '/unittest-cont1/e/file10.txt'
829 $params = array( 'srcs' => $srcs, 'dst' => $dest );
832 $params, // operation
834 $content, // content for each source
835 false, // no dest already exists
840 $params, // operation
842 $content, // content for each source
843 true, // dest already exists
851 * @dataProvider provider_testGetFileStat
853 public function testGetFileStat( $path, $content, $alreadyExists ) {
854 $this->backend
= $this->singleBackend
;
855 $this->tearDownFiles();
856 $this->doTestGetFileStat( $path, $content, $alreadyExists );
857 $this->tearDownFiles();
859 $this->backend
= $this->multiBackend
;
860 $this->tearDownFiles();
861 $this->doTestGetFileStat( $path, $content, $alreadyExists );
862 $this->tearDownFiles();
865 private function doTestGetFileStat( $path, $content, $alreadyExists ) {
866 $backendName = $this->backendClass();
868 if ( $alreadyExists ) {
869 $this->prepare( array( 'dir' => dirname( $path ) ) );
870 $status = $this->create( array( 'dst' => $path, 'content' => $content ) );
871 $this->assertGoodStatus( $status,
872 "Creation of file at $path succeeded ($backendName)." );
874 $size = $this->backend
->getFileSize( array( 'src' => $path ) );
875 $time = $this->backend
->getFileTimestamp( array( 'src' => $path ) );
876 $stat = $this->backend
->getFileStat( array( 'src' => $path ) );
878 $this->assertEquals( strlen( $content ), $size,
879 "Correct file size of '$path'" );
880 $this->assertTrue( abs( time() - wfTimestamp( TS_UNIX
, $time ) ) < 10,
881 "Correct file timestamp of '$path'" );
883 $size = $stat['size'];
884 $time = $stat['mtime'];
885 $this->assertEquals( strlen( $content ), $size,
886 "Correct file size of '$path'" );
887 $this->assertTrue( abs( time() - wfTimestamp( TS_UNIX
, $time ) ) < 10,
888 "Correct file timestamp of '$path'" );
890 $this->backend
->clearCache( array( $path ) );
892 $size = $this->backend
->getFileSize( array( 'src' => $path ) );
894 $this->assertEquals( strlen( $content ), $size,
895 "Correct file size of '$path'" );
897 $this->backend
->preloadCache( array( $path ) );
899 $size = $this->backend
->getFileSize( array( 'src' => $path ) );
901 $this->assertEquals( strlen( $content ), $size,
902 "Correct file size of '$path'" );
904 $size = $this->backend
->getFileSize( array( 'src' => $path ) );
905 $time = $this->backend
->getFileTimestamp( array( 'src' => $path ) );
906 $stat = $this->backend
->getFileStat( array( 'src' => $path ) );
908 $this->assertFalse( $size, "Correct file size of '$path'" );
909 $this->assertFalse( $time, "Correct file timestamp of '$path'" );
910 $this->assertFalse( $stat, "Correct file stat of '$path'" );
914 function provider_testGetFileStat() {
917 $base = $this->baseStorePath();
918 $cases[] = array( "$base/unittest-cont1/e/b/z/some_file.txt", "some file contents", true );
919 $cases[] = array( "$base/unittest-cont1/e/b/some-other_file.txt", "", true );
920 $cases[] = array( "$base/unittest-cont1/e/b/some-diff_file.txt", null, false );
926 * @dataProvider provider_testGetFileContents
928 public function testGetFileContents( $source, $content ) {
929 $this->backend
= $this->singleBackend
;
930 $this->tearDownFiles();
931 $this->doTestGetFileContents( $source, $content );
932 $this->tearDownFiles();
934 $this->backend
= $this->multiBackend
;
935 $this->tearDownFiles();
936 $this->doTestGetFileContents( $source, $content );
937 $this->tearDownFiles();
940 private function doTestGetFileContents( $source, $content ) {
941 $backendName = $this->backendClass();
943 $this->prepare( array( 'dir' => dirname( $source ) ) );
945 $status = $this->backend
->doOperation(
946 array( 'op' => 'create', 'content' => $content, 'dst' => $source ) );
947 $this->assertGoodStatus( $status,
948 "Creation of file at $source succeeded ($backendName)." );
949 $this->assertEquals( true, $status->isOK(),
950 "Creation of file at $source succeeded with OK status ($backendName)." );
952 $newContents = $this->backend
->getFileContents( array( 'src' => $source, 'latest' => 1 ) );
953 $this->assertNotEquals( false, $newContents,
954 "Read of file at $source succeeded ($backendName)." );
956 $this->assertEquals( $content, $newContents,
957 "Contents read match data at $source ($backendName)." );
960 function provider_testGetFileContents() {
963 $base = $this->baseStorePath();
964 $cases[] = array( "$base/unittest-cont1/e/b/z/some_file.txt", "some file contents" );
965 $cases[] = array( "$base/unittest-cont1/e/b/some-other_file.txt", "more file contents" );
971 * @dataProvider provider_testGetLocalCopy
973 public function testGetLocalCopy( $source, $content ) {
974 $this->backend
= $this->singleBackend
;
975 $this->tearDownFiles();
976 $this->doTestGetLocalCopy( $source, $content );
977 $this->tearDownFiles();
979 $this->backend
= $this->multiBackend
;
980 $this->tearDownFiles();
981 $this->doTestGetLocalCopy( $source, $content );
982 $this->tearDownFiles();
985 private function doTestGetLocalCopy( $source, $content ) {
986 $backendName = $this->backendClass();
988 $this->prepare( array( 'dir' => dirname( $source ) ) );
990 $status = $this->backend
->doOperation(
991 array( 'op' => 'create', 'content' => $content, 'dst' => $source ) );
992 $this->assertGoodStatus( $status,
993 "Creation of file at $source succeeded ($backendName)." );
995 $tmpFile = $this->backend
->getLocalCopy( array( 'src' => $source ) );
996 $this->assertNotNull( $tmpFile,
997 "Creation of local copy of $source succeeded ($backendName)." );
999 $contents = file_get_contents( $tmpFile->getPath() );
1000 $this->assertNotEquals( false, $contents, "Local copy of $source exists ($backendName)." );
1003 function provider_testGetLocalCopy() {
1006 $base = $this->baseStorePath();
1007 $cases[] = array( "$base/unittest-cont1/e/a/z/some_file.txt", "some file contents" );
1008 $cases[] = array( "$base/unittest-cont1/e/a/some-other_file.txt", "more file contents" );
1014 * @dataProvider provider_testGetLocalReference
1016 public function testGetLocalReference( $source, $content ) {
1017 $this->backend
= $this->singleBackend
;
1018 $this->tearDownFiles();
1019 $this->doTestGetLocalReference( $source, $content );
1020 $this->tearDownFiles();
1022 $this->backend
= $this->multiBackend
;
1023 $this->tearDownFiles();
1024 $this->doTestGetLocalReference( $source, $content );
1025 $this->tearDownFiles();
1028 private function doTestGetLocalReference( $source, $content ) {
1029 $backendName = $this->backendClass();
1031 $this->prepare( array( 'dir' => dirname( $source ) ) );
1033 $status = $this->create( array( 'content' => $content, 'dst' => $source ) );
1034 $this->assertGoodStatus( $status,
1035 "Creation of file at $source succeeded ($backendName)." );
1037 $tmpFile = $this->backend
->getLocalReference( array( 'src' => $source ) );
1038 $this->assertNotNull( $tmpFile,
1039 "Creation of local copy of $source succeeded ($backendName)." );
1041 $contents = file_get_contents( $tmpFile->getPath() );
1042 $this->assertNotEquals( false, $contents, "Local copy of $source exists ($backendName)." );
1045 function provider_testGetLocalReference() {
1048 $base = $this->baseStorePath();
1049 $cases[] = array( "$base/unittest-cont1/e/a/z/some_file.txt", "some file contents" );
1050 $cases[] = array( "$base/unittest-cont1/e/a/some-other_file.txt", "more file contents" );
1056 * @dataProvider provider_testPrepareAndClean
1058 public function testPrepareAndClean( $path, $isOK ) {
1059 $this->backend
= $this->singleBackend
;
1060 $this->doTestPrepareAndClean( $path, $isOK );
1061 $this->tearDownFiles();
1063 $this->backend
= $this->multiBackend
;
1064 $this->doTestPrepareAndClean( $path, $isOK );
1065 $this->tearDownFiles();
1068 function provider_testPrepareAndClean() {
1069 $base = $this->baseStorePath();
1071 array( "$base/unittest-cont1/e/a/z/some_file1.txt", true ),
1072 array( "$base/unittest-cont2/a/z/some_file2.txt", true ),
1073 # Specific to FS backend with no basePath field set
1074 #array( "$base/unittest-cont3/a/z/some_file3.txt", false ),
1078 private function doTestPrepareAndClean( $path, $isOK ) {
1079 $backendName = $this->backendClass();
1081 $status = $this->prepare( array( 'dir' => dirname( $path ) ) );
1083 $this->assertGoodStatus( $status,
1084 "Preparing dir $path succeeded without warnings ($backendName)." );
1085 $this->assertEquals( true, $status->isOK(),
1086 "Preparing dir $path succeeded ($backendName)." );
1088 $this->assertEquals( false, $status->isOK(),
1089 "Preparing dir $path failed ($backendName)." );
1092 $status = $this->backend
->clean( array( 'dir' => dirname( $path ) ) );
1094 $this->assertGoodStatus( $status,
1095 "Cleaning dir $path succeeded without warnings ($backendName)." );
1096 $this->assertEquals( true, $status->isOK(),
1097 "Cleaning dir $path succeeded ($backendName)." );
1099 $this->assertEquals( false, $status->isOK(),
1100 "Cleaning dir $path failed ($backendName)." );
1104 public function testRecursiveClean() {
1105 $this->backend
= $this->singleBackend
;
1106 $this->doTestRecursiveClean();
1107 $this->tearDownFiles();
1109 $this->backend
= $this->multiBackend
;
1110 $this->doTestRecursiveClean();
1111 $this->tearDownFiles();
1114 private function doTestRecursiveClean() {
1115 $backendName = $this->backendClass();
1117 $base = $this->baseStorePath();
1119 "$base/unittest-cont1/e/a",
1120 "$base/unittest-cont1/e/a/b",
1121 "$base/unittest-cont1/e/a/b/c",
1122 "$base/unittest-cont1/e/a/b/c/d0",
1123 "$base/unittest-cont1/e/a/b/c/d1",
1124 "$base/unittest-cont1/e/a/b/c/d2",
1125 "$base/unittest-cont1/e/a/b/c/d0/1",
1126 "$base/unittest-cont1/e/a/b/c/d0/2",
1127 "$base/unittest-cont1/e/a/b/c/d1/3",
1128 "$base/unittest-cont1/e/a/b/c/d1/4",
1129 "$base/unittest-cont1/e/a/b/c/d2/5",
1130 "$base/unittest-cont1/e/a/b/c/d2/6"
1132 foreach ( $dirs as $dir ) {
1133 $status = $this->prepare( array( 'dir' => $dir ) );
1134 $this->assertGoodStatus( $status,
1135 "Preparing dir $dir succeeded without warnings ($backendName)." );
1138 if ( $this->backend
instanceof FSFileBackend
) {
1139 foreach ( $dirs as $dir ) {
1140 $this->assertEquals( true, $this->backend
->directoryExists( array( 'dir' => $dir ) ),
1141 "Dir $dir exists ($backendName)." );
1145 $status = $this->backend
->clean(
1146 array( 'dir' => "$base/unittest-cont1", 'recursive' => 1 ) );
1147 $this->assertGoodStatus( $status,
1148 "Recursive cleaning of dir $dir succeeded without warnings ($backendName)." );
1150 foreach ( $dirs as $dir ) {
1151 $this->assertEquals( false, $this->backend
->directoryExists( array( 'dir' => $dir ) ),
1152 "Dir $dir no longer exists ($backendName)." );
1156 // @TODO: testSecure
1158 public function testDoOperations() {
1159 $this->backend
= $this->singleBackend
;
1160 $this->tearDownFiles();
1161 $this->doTestDoOperations();
1162 $this->tearDownFiles();
1164 $this->backend
= $this->multiBackend
;
1165 $this->tearDownFiles();
1166 $this->doTestDoOperations();
1167 $this->tearDownFiles();
1170 private function doTestDoOperations() {
1171 $base = $this->baseStorePath();
1173 $fileA = "$base/unittest-cont1/e/a/b/fileA.txt";
1174 $fileAContents = '3tqtmoeatmn4wg4qe-mg3qt3 tq';
1175 $fileB = "$base/unittest-cont1/e/a/b/fileB.txt";
1176 $fileBContents = 'g-jmq3gpqgt3qtg q3GT ';
1177 $fileC = "$base/unittest-cont1/e/a/b/fileC.txt";
1178 $fileCContents = 'eigna[ogmewt 3qt g3qg flew[ag';
1179 $fileD = "$base/unittest-cont1/e/a/b/fileD.txt";
1181 $this->prepare( array( 'dir' => dirname( $fileA ) ) );
1182 $this->create( array( 'dst' => $fileA, 'content' => $fileAContents ) );
1183 $this->prepare( array( 'dir' => dirname( $fileB ) ) );
1184 $this->create( array( 'dst' => $fileB, 'content' => $fileBContents ) );
1185 $this->prepare( array( 'dir' => dirname( $fileC ) ) );
1186 $this->create( array( 'dst' => $fileC, 'content' => $fileCContents ) );
1187 $this->prepare( array( 'dir' => dirname( $fileD ) ) );
1189 $status = $this->backend
->doOperations( array(
1190 array( 'op' => 'copy', 'src' => $fileA, 'dst' => $fileC, 'overwrite' => 1 ),
1191 // Now: A:<A>, B:<B>, C:<A>, D:<empty> (file:<orginal contents>)
1192 array( 'op' => 'copy', 'src' => $fileC, 'dst' => $fileA, 'overwriteSame' => 1 ),
1193 // Now: A:<A>, B:<B>, C:<A>, D:<empty>
1194 array( 'op' => 'move', 'src' => $fileC, 'dst' => $fileD, 'overwrite' => 1 ),
1195 // Now: A:<A>, B:<B>, C:<empty>, D:<A>
1196 array( 'op' => 'move', 'src' => $fileB, 'dst' => $fileC ),
1197 // Now: A:<A>, B:<empty>, C:<B>, D:<A>
1198 array( 'op' => 'move', 'src' => $fileD, 'dst' => $fileA, 'overwriteSame' => 1 ),
1199 // Now: A:<A>, B:<empty>, C:<B>, D:<empty>
1200 array( 'op' => 'move', 'src' => $fileC, 'dst' => $fileA, 'overwrite' => 1 ),
1201 // Now: A:<B>, B:<empty>, C:<empty>, D:<empty>
1202 array( 'op' => 'copy', 'src' => $fileA, 'dst' => $fileC ),
1203 // Now: A:<B>, B:<empty>, C:<B>, D:<empty>
1204 array( 'op' => 'move', 'src' => $fileA, 'dst' => $fileC, 'overwriteSame' => 1 ),
1205 // Now: A:<empty>, B:<empty>, C:<B>, D:<empty>
1206 array( 'op' => 'copy', 'src' => $fileC, 'dst' => $fileC, 'overwrite' => 1 ),
1208 array( 'op' => 'copy', 'src' => $fileC, 'dst' => $fileC, 'overwriteSame' => 1 ),
1210 array( 'op' => 'move', 'src' => $fileC, 'dst' => $fileC, 'overwrite' => 1 ),
1212 array( 'op' => 'move', 'src' => $fileC, 'dst' => $fileC, 'overwriteSame' => 1 ),
1214 array( 'op' => 'null' ),
1218 $this->assertGoodStatus( $status, "Operation batch succeeded" );
1219 $this->assertEquals( true, $status->isOK(), "Operation batch succeeded" );
1220 $this->assertEquals( 13, count( $status->success
),
1221 "Operation batch has correct success array" );
1223 $this->assertEquals( false, $this->backend
->fileExists( array( 'src' => $fileA ) ),
1224 "File does not exist at $fileA" );
1225 $this->assertEquals( false, $this->backend
->fileExists( array( 'src' => $fileB ) ),
1226 "File does not exist at $fileB" );
1227 $this->assertEquals( false, $this->backend
->fileExists( array( 'src' => $fileD ) ),
1228 "File does not exist at $fileD" );
1230 $this->assertEquals( true, $this->backend
->fileExists( array( 'src' => $fileC ) ),
1231 "File exists at $fileC" );
1232 $this->assertEquals( $fileBContents,
1233 $this->backend
->getFileContents( array( 'src' => $fileC ) ),
1234 "Correct file contents of $fileC" );
1235 $this->assertEquals( strlen( $fileBContents ),
1236 $this->backend
->getFileSize( array( 'src' => $fileC ) ),
1237 "Correct file size of $fileC" );
1238 $this->assertEquals( wfBaseConvert( sha1( $fileBContents ), 16, 36, 31 ),
1239 $this->backend
->getFileSha1Base36( array( 'src' => $fileC ) ),
1240 "Correct file SHA-1 of $fileC" );
1243 public function testDoOperationsPipeline() {
1244 $this->backend
= $this->singleBackend
;
1245 $this->tearDownFiles();
1246 $this->doTestDoOperationsPipeline();
1247 $this->tearDownFiles();
1249 $this->backend
= $this->multiBackend
;
1250 $this->tearDownFiles();
1251 $this->doTestDoOperationsPipeline();
1252 $this->tearDownFiles();
1255 // concurrency orientated
1256 private function doTestDoOperationsPipeline() {
1257 $base = $this->baseStorePath();
1259 $fileAContents = '3tqtmoeatmn4wg4qe-mg3qt3 tq';
1260 $fileBContents = 'g-jmq3gpqgt3qtg q3GT ';
1261 $fileCContents = 'eigna[ogmewt 3qt g3qg flew[ag';
1263 $tmpNameA = TempFSFile
::factory( "unittests_", 'txt' )->getPath();
1264 file_put_contents( $tmpNameA, $fileAContents );
1265 $tmpNameB = TempFSFile
::factory( "unittests_", 'txt' )->getPath();
1266 file_put_contents( $tmpNameB, $fileBContents );
1267 $tmpNameC = TempFSFile
::factory( "unittests_", 'txt' )->getPath();
1268 file_put_contents( $tmpNameC, $fileCContents );
1270 $this->filesToPrune
[] = $tmpNameA; # avoid file leaking
1271 $this->filesToPrune
[] = $tmpNameB; # avoid file leaking
1272 $this->filesToPrune
[] = $tmpNameC; # avoid file leaking
1274 $fileA = "$base/unittest-cont1/e/a/b/fileA.txt";
1275 $fileB = "$base/unittest-cont1/e/a/b/fileB.txt";
1276 $fileC = "$base/unittest-cont1/e/a/b/fileC.txt";
1277 $fileD = "$base/unittest-cont1/e/a/b/fileD.txt";
1279 $this->prepare( array( 'dir' => dirname( $fileA ) ) );
1280 $this->create( array( 'dst' => $fileA, 'content' => $fileAContents ) );
1281 $this->prepare( array( 'dir' => dirname( $fileB ) ) );
1282 $this->prepare( array( 'dir' => dirname( $fileC ) ) );
1283 $this->prepare( array( 'dir' => dirname( $fileD ) ) );
1285 $status = $this->backend
->doOperations( array(
1286 array( 'op' => 'store', 'src' => $tmpNameA, 'dst' => $fileA, 'overwriteSame' => 1 ),
1287 array( 'op' => 'store', 'src' => $tmpNameB, 'dst' => $fileB, 'overwrite' => 1 ),
1288 array( 'op' => 'store', 'src' => $tmpNameC, 'dst' => $fileC, 'overwrite' => 1 ),
1289 array( 'op' => 'copy', 'src' => $fileA, 'dst' => $fileC, 'overwrite' => 1 ),
1290 // Now: A:<A>, B:<B>, C:<A>, D:<empty> (file:<orginal contents>)
1291 array( 'op' => 'copy', 'src' => $fileC, 'dst' => $fileA, 'overwriteSame' => 1 ),
1292 // Now: A:<A>, B:<B>, C:<A>, D:<empty>
1293 array( 'op' => 'move', 'src' => $fileC, 'dst' => $fileD, 'overwrite' => 1 ),
1294 // Now: A:<A>, B:<B>, C:<empty>, D:<A>
1295 array( 'op' => 'move', 'src' => $fileB, 'dst' => $fileC ),
1296 // Now: A:<A>, B:<empty>, C:<B>, D:<A>
1297 array( 'op' => 'move', 'src' => $fileD, 'dst' => $fileA, 'overwriteSame' => 1 ),
1298 // Now: A:<A>, B:<empty>, C:<B>, D:<empty>
1299 array( 'op' => 'move', 'src' => $fileC, 'dst' => $fileA, 'overwrite' => 1 ),
1300 // Now: A:<B>, B:<empty>, C:<empty>, D:<empty>
1301 array( 'op' => 'copy', 'src' => $fileA, 'dst' => $fileC ),
1302 // Now: A:<B>, B:<empty>, C:<B>, D:<empty>
1303 array( 'op' => 'move', 'src' => $fileA, 'dst' => $fileC, 'overwriteSame' => 1 ),
1304 // Now: A:<empty>, B:<empty>, C:<B>, D:<empty>
1305 array( 'op' => 'copy', 'src' => $fileC, 'dst' => $fileC, 'overwrite' => 1 ),
1307 array( 'op' => 'copy', 'src' => $fileC, 'dst' => $fileC, 'overwriteSame' => 1 ),
1309 array( 'op' => 'move', 'src' => $fileC, 'dst' => $fileC, 'overwrite' => 1 ),
1311 array( 'op' => 'move', 'src' => $fileC, 'dst' => $fileC, 'overwriteSame' => 1 ),
1313 array( 'op' => 'null' ),
1317 $this->assertGoodStatus( $status, "Operation batch succeeded" );
1318 $this->assertEquals( true, $status->isOK(), "Operation batch succeeded" );
1319 $this->assertEquals( 16, count( $status->success
),
1320 "Operation batch has correct success array" );
1322 $this->assertEquals( false, $this->backend
->fileExists( array( 'src' => $fileA ) ),
1323 "File does not exist at $fileA" );
1324 $this->assertEquals( false, $this->backend
->fileExists( array( 'src' => $fileB ) ),
1325 "File does not exist at $fileB" );
1326 $this->assertEquals( false, $this->backend
->fileExists( array( 'src' => $fileD ) ),
1327 "File does not exist at $fileD" );
1329 $this->assertEquals( true, $this->backend
->fileExists( array( 'src' => $fileC ) ),
1330 "File exists at $fileC" );
1331 $this->assertEquals( $fileBContents,
1332 $this->backend
->getFileContents( array( 'src' => $fileC ) ),
1333 "Correct file contents of $fileC" );
1334 $this->assertEquals( strlen( $fileBContents ),
1335 $this->backend
->getFileSize( array( 'src' => $fileC ) ),
1336 "Correct file size of $fileC" );
1337 $this->assertEquals( wfBaseConvert( sha1( $fileBContents ), 16, 36, 31 ),
1338 $this->backend
->getFileSha1Base36( array( 'src' => $fileC ) ),
1339 "Correct file SHA-1 of $fileC" );
1342 public function testDoOperationsFailing() {
1343 $this->backend
= $this->singleBackend
;
1344 $this->tearDownFiles();
1345 $this->doTestDoOperationsFailing();
1346 $this->tearDownFiles();
1348 $this->backend
= $this->multiBackend
;
1349 $this->tearDownFiles();
1350 $this->doTestDoOperationsFailing();
1351 $this->tearDownFiles();
1354 private function doTestDoOperationsFailing() {
1355 $base = $this->baseStorePath();
1357 $fileA = "$base/unittest-cont2/a/b/fileA.txt";
1358 $fileAContents = '3tqtmoeatmn4wg4qe-mg3qt3 tq';
1359 $fileB = "$base/unittest-cont2/a/b/fileB.txt";
1360 $fileBContents = 'g-jmq3gpqgt3qtg q3GT ';
1361 $fileC = "$base/unittest-cont2/a/b/fileC.txt";
1362 $fileCContents = 'eigna[ogmewt 3qt g3qg flew[ag';
1363 $fileD = "$base/unittest-cont2/a/b/fileD.txt";
1365 $this->prepare( array( 'dir' => dirname( $fileA ) ) );
1366 $this->create( array( 'dst' => $fileA, 'content' => $fileAContents ) );
1367 $this->prepare( array( 'dir' => dirname( $fileB ) ) );
1368 $this->create( array( 'dst' => $fileB, 'content' => $fileBContents ) );
1369 $this->prepare( array( 'dir' => dirname( $fileC ) ) );
1370 $this->create( array( 'dst' => $fileC, 'content' => $fileCContents ) );
1372 $status = $this->backend
->doOperations( array(
1373 array( 'op' => 'copy', 'src' => $fileA, 'dst' => $fileC, 'overwrite' => 1 ),
1374 // Now: A:<A>, B:<B>, C:<A>, D:<empty> (file:<orginal contents>)
1375 array( 'op' => 'copy', 'src' => $fileC, 'dst' => $fileA, 'overwriteSame' => 1 ),
1376 // Now: A:<A>, B:<B>, C:<A>, D:<empty>
1377 array( 'op' => 'copy', 'src' => $fileB, 'dst' => $fileD, 'overwrite' => 1 ),
1378 // Now: A:<A>, B:<B>, C:<A>, D:<B>
1379 array( 'op' => 'move', 'src' => $fileC, 'dst' => $fileD ),
1380 // Now: A:<A>, B:<B>, C:<A>, D:<empty> (failed)
1381 array( 'op' => 'move', 'src' => $fileB, 'dst' => $fileC, 'overwriteSame' => 1 ),
1382 // Now: A:<A>, B:<B>, C:<A>, D:<empty> (failed)
1383 array( 'op' => 'move', 'src' => $fileB, 'dst' => $fileA, 'overwrite' => 1 ),
1384 // Now: A:<B>, B:<empty>, C:<A>, D:<empty>
1385 array( 'op' => 'delete', 'src' => $fileD ),
1386 // Now: A:<B>, B:<empty>, C:<A>, D:<empty>
1387 array( 'op' => 'null' ),
1389 ), array( 'force' => 1 ) );
1391 $this->assertNotEquals( array(), $status->errors
, "Operation had warnings" );
1392 $this->assertEquals( true, $status->isOK(), "Operation batch succeeded" );
1393 $this->assertEquals( 8, count( $status->success
),
1394 "Operation batch has correct success array" );
1396 $this->assertEquals( false, $this->backend
->fileExists( array( 'src' => $fileB ) ),
1397 "File does not exist at $fileB" );
1398 $this->assertEquals( false, $this->backend
->fileExists( array( 'src' => $fileD ) ),
1399 "File does not exist at $fileD" );
1401 $this->assertEquals( true, $this->backend
->fileExists( array( 'src' => $fileA ) ),
1402 "File does not exist at $fileA" );
1403 $this->assertEquals( true, $this->backend
->fileExists( array( 'src' => $fileC ) ),
1404 "File exists at $fileC" );
1405 $this->assertEquals( $fileBContents,
1406 $this->backend
->getFileContents( array( 'src' => $fileA ) ),
1407 "Correct file contents of $fileA" );
1408 $this->assertEquals( strlen( $fileBContents ),
1409 $this->backend
->getFileSize( array( 'src' => $fileA ) ),
1410 "Correct file size of $fileA" );
1411 $this->assertEquals( wfBaseConvert( sha1( $fileBContents ), 16, 36, 31 ),
1412 $this->backend
->getFileSha1Base36( array( 'src' => $fileA ) ),
1413 "Correct file SHA-1 of $fileA" );
1416 public function testGetFileList() {
1417 $this->backend
= $this->singleBackend
;
1418 $this->tearDownFiles();
1419 $this->doTestGetFileList();
1420 $this->tearDownFiles();
1422 $this->backend
= $this->multiBackend
;
1423 $this->tearDownFiles();
1424 $this->doTestGetFileList();
1425 $this->tearDownFiles();
1428 private function doTestGetFileList() {
1429 $backendName = $this->backendClass();
1430 $base = $this->baseStorePath();
1432 // Should have no errors
1433 $iter = $this->backend
->getFileList( array( 'dir' => "$base/unittest-cont-notexists" ) );
1436 "$base/unittest-cont1/e/test1.txt",
1437 "$base/unittest-cont1/e/test2.txt",
1438 "$base/unittest-cont1/e/test3.txt",
1439 "$base/unittest-cont1/e/subdir1/test1.txt",
1440 "$base/unittest-cont1/e/subdir1/test2.txt",
1441 "$base/unittest-cont1/e/subdir2/test3.txt",
1442 "$base/unittest-cont1/e/subdir2/test4.txt",
1443 "$base/unittest-cont1/e/subdir2/subdir/test1.txt",
1444 "$base/unittest-cont1/e/subdir2/subdir/test2.txt",
1445 "$base/unittest-cont1/e/subdir2/subdir/test3.txt",
1446 "$base/unittest-cont1/e/subdir2/subdir/test4.txt",
1447 "$base/unittest-cont1/e/subdir2/subdir/test5.txt",
1448 "$base/unittest-cont1/e/subdir2/subdir/sub/test0.txt",
1449 "$base/unittest-cont1/e/subdir2/subdir/sub/120-px-file.txt",
1454 foreach ( $files as $file ) {
1455 $this->prepare( array( 'dir' => dirname( $file ) ) );
1456 $ops[] = array( 'op' => 'create', 'content' => 'xxy', 'dst' => $file );
1458 $status = $this->backend
->doQuickOperations( $ops );
1459 $this->assertGoodStatus( $status,
1460 "Creation of files succeeded ($backendName)." );
1461 $this->assertEquals( true, $status->isOK(),
1462 "Creation of files succeeded with OK status ($backendName)." );
1469 "e/subdir1/test1.txt",
1470 "e/subdir1/test2.txt",
1471 "e/subdir2/test3.txt",
1472 "e/subdir2/test4.txt",
1473 "e/subdir2/subdir/test1.txt",
1474 "e/subdir2/subdir/test2.txt",
1475 "e/subdir2/subdir/test3.txt",
1476 "e/subdir2/subdir/test4.txt",
1477 "e/subdir2/subdir/test5.txt",
1478 "e/subdir2/subdir/sub/test0.txt",
1479 "e/subdir2/subdir/sub/120-px-file.txt",
1483 // Actual listing (no trailing slash)
1485 $iter = $this->backend
->getFileList( array( 'dir' => "$base/unittest-cont1" ) );
1486 foreach ( $iter as $file ) {
1491 $this->assertEquals( $expected, $list, "Correct file listing ($backendName)." );
1493 // Actual listing (with trailing slash)
1495 $iter = $this->backend
->getFileList( array( 'dir' => "$base/unittest-cont1/" ) );
1496 foreach ( $iter as $file ) {
1501 $this->assertEquals( $expected, $list, "Correct file listing ($backendName)." );
1511 "sub/120-px-file.txt",
1515 // Actual listing (no trailing slash)
1517 $iter = $this->backend
->getFileList( array( 'dir' => "$base/unittest-cont1/e/subdir2/subdir" ) );
1518 foreach ( $iter as $file ) {
1523 $this->assertEquals( $expected, $list, "Correct file listing ($backendName)." );
1525 // Actual listing (with trailing slash)
1527 $iter = $this->backend
->getFileList( array( 'dir' => "$base/unittest-cont1/e/subdir2/subdir/" ) );
1528 foreach ( $iter as $file ) {
1533 $this->assertEquals( $expected, $list, "Correct file listing ($backendName)." );
1535 // Actual listing (using iterator second time)
1537 foreach ( $iter as $file ) {
1542 $this->assertEquals( $expected, $list, "Correct file listing ($backendName), second iteration." );
1544 // Expected listing (top files only)
1554 // Actual listing (top files only)
1556 $iter = $this->backend
->getTopFileList( array( 'dir' => "$base/unittest-cont1/e/subdir2/subdir" ) );
1557 foreach ( $iter as $file ) {
1562 $this->assertEquals( $expected, $list, "Correct top file listing ($backendName)." );
1564 foreach ( $files as $file ) { // clean up
1565 $this->backend
->doOperation( array( 'op' => 'delete', 'src' => $file ) );
1568 $iter = $this->backend
->getFileList( array( 'dir' => "$base/unittest-cont1/not/exists" ) );
1569 foreach ( $iter as $iter ) {} // no errors
1572 public function testGetDirectoryList() {
1573 $this->backend
= $this->singleBackend
;
1574 $this->tearDownFiles();
1575 $this->doTestGetDirectoryList();
1576 $this->tearDownFiles();
1578 $this->backend
= $this->multiBackend
;
1579 $this->tearDownFiles();
1580 $this->doTestGetDirectoryList();
1581 $this->tearDownFiles();
1584 private function doTestGetDirectoryList() {
1585 $backendName = $this->backendClass();
1587 $base = $this->baseStorePath();
1589 "$base/unittest-cont1/e/test1.txt",
1590 "$base/unittest-cont1/e/test2.txt",
1591 "$base/unittest-cont1/e/test3.txt",
1592 "$base/unittest-cont1/e/subdir1/test1.txt",
1593 "$base/unittest-cont1/e/subdir1/test2.txt",
1594 "$base/unittest-cont1/e/subdir2/test3.txt",
1595 "$base/unittest-cont1/e/subdir2/test4.txt",
1596 "$base/unittest-cont1/e/subdir2/subdir/test1.txt",
1597 "$base/unittest-cont1/e/subdir3/subdir/test2.txt",
1598 "$base/unittest-cont1/e/subdir4/subdir/test3.txt",
1599 "$base/unittest-cont1/e/subdir4/subdir/test4.txt",
1600 "$base/unittest-cont1/e/subdir4/subdir/test5.txt",
1601 "$base/unittest-cont1/e/subdir4/subdir/sub/test0.txt",
1602 "$base/unittest-cont1/e/subdir4/subdir/sub/120-px-file.txt",
1607 foreach ( $files as $file ) {
1608 $this->prepare( array( 'dir' => dirname( $file ) ) );
1609 $ops[] = array( 'op' => 'create', 'content' => 'xxy', 'dst' => $file );
1611 $status = $this->backend
->doQuickOperations( $ops );
1612 $this->assertGoodStatus( $status,
1613 "Creation of files succeeded ($backendName)." );
1614 $this->assertEquals( true, $status->isOK(),
1615 "Creation of files succeeded with OK status ($backendName)." );
1617 $this->assertEquals( true,
1618 $this->backend
->directoryExists( array( 'dir' => "$base/unittest-cont1/e/subdir1" ) ),
1619 "Directory exists in ($backendName)." );
1620 $this->assertEquals( true,
1621 $this->backend
->directoryExists( array( 'dir' => "$base/unittest-cont1/e/subdir2/subdir" ) ),
1622 "Directory exists in ($backendName)." );
1623 $this->assertEquals( false,
1624 $this->backend
->directoryExists( array( 'dir' => "$base/unittest-cont1/e/subdir2/test1.txt" ) ),
1625 "Directory does not exists in ($backendName)." );
1633 // Actual listing (no trailing slash)
1635 $iter = $this->backend
->getTopDirectoryList( array( 'dir' => "$base/unittest-cont1" ) );
1636 foreach ( $iter as $file ) {
1641 $this->assertEquals( $expected, $list, "Correct top dir listing ($backendName)." );
1652 // Actual listing (no trailing slash)
1654 $iter = $this->backend
->getTopDirectoryList( array( 'dir' => "$base/unittest-cont1/e" ) );
1655 foreach ( $iter as $file ) {
1660 $this->assertEquals( $expected, $list, "Correct top dir listing ($backendName)." );
1662 // Actual listing (with trailing slash)
1664 $iter = $this->backend
->getTopDirectoryList( array( 'dir' => "$base/unittest-cont1/e/" ) );
1665 foreach ( $iter as $file ) {
1670 $this->assertEquals( $expected, $list, "Correct top dir listing ($backendName)." );
1678 // Actual listing (no trailing slash)
1680 $iter = $this->backend
->getTopDirectoryList( array( 'dir' => "$base/unittest-cont1/e/subdir2" ) );
1681 foreach ( $iter as $file ) {
1686 $this->assertEquals( $expected, $list, "Correct top dir listing ($backendName)." );
1688 // Actual listing (with trailing slash)
1690 $iter = $this->backend
->getTopDirectoryList( array( 'dir' => "$base/unittest-cont1/e/subdir2/" ) );
1691 foreach ( $iter as $file ) {
1696 $this->assertEquals( $expected, $list, "Correct top dir listing ($backendName)." );
1698 // Actual listing (using iterator second time)
1700 foreach ( $iter as $file ) {
1705 $this->assertEquals( $expected, $list, "Correct top dir listing ($backendName), second iteration." );
1707 // Expected listing (recursive)
1717 "e/subdir4/subdir/sub",
1721 // Actual listing (recursive)
1723 $iter = $this->backend
->getDirectoryList( array( 'dir' => "$base/unittest-cont1/" ) );
1724 foreach ( $iter as $file ) {
1729 $this->assertEquals( $expected, $list, "Correct dir listing ($backendName)." );
1731 // Expected listing (recursive)
1738 // Actual listing (recursive)
1740 $iter = $this->backend
->getDirectoryList( array( 'dir' => "$base/unittest-cont1/e/subdir4" ) );
1741 foreach ( $iter as $file ) {
1746 $this->assertEquals( $expected, $list, "Correct dir listing ($backendName)." );
1748 // Actual listing (recursive, second time)
1750 foreach ( $iter as $file ) {
1755 $this->assertEquals( $expected, $list, "Correct dir listing ($backendName)." );
1757 foreach ( $files as $file ) { // clean up
1758 $this->backend
->doOperation( array( 'op' => 'delete', 'src' => $file ) );
1761 $iter = $this->backend
->getDirectoryList( array( 'dir' => "$base/unittest-cont1/not/exists" ) );
1762 foreach ( $iter as $iter ) {} // no errors
1765 public function testLockCalls() {
1766 $this->backend
= $this->singleBackend
;
1767 $this->doTestLockCalls();
1770 private function doTestLockCalls() {
1771 $backendName = $this->backendClass();
1773 for ( $i=0; $i<50; $i++
) {
1779 "subdir1", // duplicate
1780 "subdir1/test1.txt",
1781 "subdir1/test2.txt",
1783 "subdir2", // duplicate
1784 "subdir2/test3.txt",
1785 "subdir2/test4.txt",
1787 "subdir2/subdir/test1.txt",
1788 "subdir2/subdir/test2.txt",
1789 "subdir2/subdir/test3.txt",
1790 "subdir2/subdir/test4.txt",
1791 "subdir2/subdir/test5.txt",
1792 "subdir2/subdir/sub",
1793 "subdir2/subdir/sub/test0.txt",
1794 "subdir2/subdir/sub/120-px-file.txt",
1797 $status = $this->backend
->lockFiles( $paths, LockManager
::LOCK_EX
);
1798 $this->assertEquals( array(), $status->errors
,
1799 "Locking of files succeeded ($backendName)." );
1800 $this->assertEquals( true, $status->isOK(),
1801 "Locking of files succeeded with OK status ($backendName)." );
1803 $status = $this->backend
->lockFiles( $paths, LockManager
::LOCK_SH
);
1804 $this->assertEquals( array(), $status->errors
,
1805 "Locking of files succeeded ($backendName)." );
1806 $this->assertEquals( true, $status->isOK(),
1807 "Locking of files succeeded with OK status ($backendName)." );
1809 $status = $this->backend
->unlockFiles( $paths, LockManager
::LOCK_SH
);
1810 $this->assertEquals( array(), $status->errors
,
1811 "Locking of files succeeded ($backendName)." );
1812 $this->assertEquals( true, $status->isOK(),
1813 "Locking of files succeeded with OK status ($backendName)." );
1815 $status = $this->backend
->unlockFiles( $paths, LockManager
::LOCK_EX
);
1816 $this->assertEquals( array(), $status->errors
,
1817 "Locking of files succeeded ($backendName)." );
1818 $this->assertEquals( true, $status->isOK(),
1819 "Locking of files succeeded with OK status ($backendName)." );
1823 // test helper wrapper for backend prepare() function
1824 private function prepare( array $params ) {
1825 return $this->backend
->prepare( $params );
1828 // test helper wrapper for backend prepare() function
1829 private function create( array $params ) {
1830 $params['op'] = 'create';
1831 return $this->backend
->doQuickOperations( array( $params ) );
1834 function tearDownFiles() {
1835 foreach ( $this->filesToPrune
as $file ) {
1838 $containers = array( 'unittest-cont1', 'unittest-cont2', 'unittest-cont3' );
1839 foreach ( $containers as $container ) {
1840 $this->deleteFiles( $container );
1842 $this->filesToPrune
= array();
1845 private function deleteFiles( $container ) {
1846 $base = $this->baseStorePath();
1847 $iter = $this->backend
->getFileList( array( 'dir' => "$base/$container" ) );
1849 foreach ( $iter as $file ) {
1850 $this->backend
->delete( array( 'src' => "$base/$container/$file" ),
1851 array( 'force' => 1, 'nonLocking' => 1 ) );
1854 $this->backend
->clean( array( 'dir' => "$base/$container", 'recursive' => 1 ) );
1857 function assertBackendPathsConsistent( array $paths ) {
1858 if ( $this->backend
instanceof FileBackendMultiWrite
) {
1859 $status = $this->backend
->consistencyCheck( $paths );
1860 $this->assertGoodStatus( $status, "Files synced: " . implode( ',', $paths ) );
1864 function assertGoodStatus( $status, $msg ) {
1865 $this->assertEquals( print_r( array(), 1 ), print_r( $status->errors
, 1 ), $msg );
1868 function tearDown() {